#include <iostream>
#include <string>
#include <mutex>

// class CopyBan {
// public:
//     // ...
// private:
//     CopyBan(const CopyBan&);
//     CopyBan& operator=(const CopyBan&);
//     // ...
// };

class CopyBan {
public:
    // ...
    CopyBan(const CopyBan&) = delete;
    CopyBan& operator=(const CopyBan&) = delete;
};

class HeapOnly {
public:
    static HeapOnly* CreateObj() {
        return new HeapOnly;
    }

    // ...
    ~HeapOnly() {
        delete this;
    }
private:
    HeapOnly() {}

    HeapOnly(const HeapOnly&) {}
    // HeapOnly(const HeapOnly&) = delete;
    // ...
};

class StackOnly {
public:
    static StackOnly CreateObj() {
        return StackOnly();
    }

    void* operator new(size_t size) = delete;
    void operator delete(void* p) = delete;
    // ...
private:
    StackOnly() {}
};

class NonIherit {
public:
    static NonIherit GetInstance() {
        return NonIherit();
    }
private:
    NonIherit() {}
};

// class NonIherit final {
//     // ...
// }

// class ConfigInfo {
// public:
//     static ConfigInfo* GetInstance() {
//         return &_sinfo;
//     }
// // 删除拷贝构造和赋值重载
//     ConfigInfo(const ConfigInfo&) = delete;
//     ConfigInfo& operator=(const ConfigInfo&) = delete;

// private:
//     // 构造函数私有化
//     ConfigInfo() {}

//     std::string _ip;
//     uint16_t _port;
//     // ...

//     // 静态变量，在类内声明
//     static ConfigInfo _sinfo;
// };

// // 类外定义
// ConfigInfo ConfigInfo::_sinfo;

class ConfigInfo {
public:
    static ConfigInfo* GetInstance() {
        // 这种方式在C++11之前，多线程调用会存在线程安全问题
        // 可能会创建出多个单例对象
        // C++11对该问题进行了特殊处理
        static ConfigInfo info;
        return &info;
    }

    // static ConfigInfo* GetInstance() {
    //     if (_spinfo == nullptr) {
    //         std::unique_lock<std::mutex> lock(_mtx);
    //         if (_spinfo == nullptr) 
    //             _spinfo = new ConfigInfo;
            
    //     }
    //     return _spinfo;
    // }

    // 删除拷贝构造和赋值重载
    ConfigInfo(const ConfigInfo&) = delete;
    ConfigInfo& operator=(const ConfigInfo&) = delete;
    // ...

    void SetIp(const std::string& ip) {
        _ip = ip;
    }

    std::string GetIp() {
        return _ip;
    }
private:
    // 构造函数私有化
    ConfigInfo() {}

    std::string _ip;
    uint16_t _port;
    // ...

    static std::mutex _mtx;
    static ConfigInfo* _spinfo;
};

std::mutex ConfigInfo::_mtx;
ConfigInfo* ConfigInfo::_spinfo = nullptr;

// 类外定义
// ConfigInfo ConfigInfo::_sinfo;


// int main() {
//     // StackOnly so;
//     ConfigInfo::GetInstance()->SetIp("127.0.0.1");
//     std::cout << ConfigInfo::GetInstance()->GetIp() << std::endl;
//     return 0;
// }

// int main() {
//     int i = 1;
//     // 隐式类型转换
//     double d = i;
    

//     int* p = &i;
//     // 显示类型转换
//     int addr = (int)p;
//     std::cout << addr << ":" << p << std::endl;
//     return 0;
// }

int main() {
    const int a = 1;
    int x = 2;
    std::cout << &x << std::endl;
    std::cout << &a << std::endl;
    
    int* pa = (int*)&a;
    (*pa)++;
    std::cout << *pa << std::endl;
    std::cout << a << std::endl;
    return 0;
}